// src/stores/useMenuStore.js
import {defineStore} from 'pinia'
import * as menuApi from '@/api/menu';

/**
 * 菜单是否已存在层级关系
 */
function isNestedMenu(menu) {
  return menu.some(item => item.children && item.children.length > 0);
}
/**
 * 将扁平数组转换为树形结构
 */
function listToTree(list, parentId = 0) {
  return list
    .filter(item => item.parent_id === parentId)
    .map(item => ({
      ...item,
      children: listToTree(list, item.id)
    }))
    .filter(item => {
      // 如果当前节点是父节点但没有子节点，也可以保留它
      return true;
    });
}

/**
 * 获取菜单列表并转换为树形结构
 */
async function fetchMenuList() {
    try {
        const data = await menuApi.getMenuList();
        const menuList = data.data;
        console.log(menuList)
        let menuTree;

        if (isNestedMenu(menuList)) {
            menuTree = menuList; // 已嵌套，直接使用
        } else {
            menuTree = listToTree(menuList); // 需要转换
        }
        console.log("最终菜单树:", menuTree);
        return menuTree;
    } catch (error) {
        console.error('获取菜单失败:', error);
        throw error;
    }
}

export const useMenuStore = defineStore('menu', {
    state: () => ({
        menuList: [],
        loading: false,
        collapse: false, // 示例字段，可按需添加
        isFetching: false, // 新增状态标志
        hasInitialized: false // 添加初始化状态
    }),
    getters: {
        /**
         * 这是一个 getter，用于获取菜单树数据
         * 它直接返回 state 中的 menuList 数据
         * 当 menuList 数据更新时，这个 getter 返回的值也会自动更新
         */
        getMenuTree(state) {
            return state.menuList
        },
        // 扁平化菜单（带层级信息）
        flatMenuListWithLevel(state) {
            const flattenMenus = (menus, level = 0) => {
                let result = []
                menus.forEach(menu => {
                    result.push({ ...menu, level })
                    if (menu.children && menu.children.length > 0) {
                        result = result.concat(flattenMenus(menu.children, level + 1))
                    }
                })
                return result
            }
            return flattenMenus(state.menuList)
        },
        // 扁平化菜单
        flatMenuList(state) {
            const flattenMenus = (menus) => {
                return menus.reduce((acc, menu) => {
                    acc.push({ label: menu.name, value: menu.id })
                    if (menu.children && menu.children.length > 0) {
                        acc.push(...flattenMenus(menu.children))
                    }
                    return acc
                }, [])
            }
            return flattenMenus(state.menuList)
        }
    },
    actions: {
        async fetchMenu(force = false) {
            // 如果已经在获取中且未强制刷新，则直接返回
            if (this.isFetching && !force) {
                return Promise.resolve(this.menuList)
            }

            this.loading = true
            this.isFetching = true
            
            try {
                // 检查是否已有数据且非强制刷新
                if (this.menuList && this.menuList.length > 0 && !force) {
                    return this.menuList
                }

                const data = await fetchMenuList()
                this.menuList = data
                return data
            } catch (error) {
                console.error('获取菜单失败:', error)
                return [] // 修改这里，返回空数组而不是现有的 menuList
            } finally {
                this.loading = false
                this.isFetching = false
            }
        },
        
        // 更新单个菜单项
        updateMenuItem(updatedMenu) {
            // 创建新的菜单列表
            const updatedList = this.menuList.map(item => 
                item.id === updatedMenu.id ? {...item, ...updatedMenu} : item
            );
            
            // 更新 store 中的数据
            this.menuList = updatedList;
            
            // 返回更新后的数据
            return updatedList;
        },
        
        // 添加新菜单项
        addMenuItem(newMenu) {
            // 在客户端生成新ID（生产环境应由服务器生成）
            const newId = Math.max(...this.menuList.map(m => m.id), 0) + 1;
            const menuItem = {...newMenu, id: newId};
            
            // 添加到列表
            this.menuList = [...this.menuList, menuItem];
            
            // 返回新增的数据
            return menuItem;
        },
        
        // 删除菜单项
        deleteMenuItem(deletedId) {
            // 过滤掉被删除的项
            this.menuList = this.menuList.filter(item => item.id !== deletedId);
            
            // 返回删除的ID
            return deletedId;
        },

        toggleCollapse() {
            this.collapse = !this.collapse
        }
    },
})